import api from '../api/api.js';

/**
 * 从本地存储获取Token
 * @returns {Promise} 包含token的Promise
 */
const getToken = () => {
  return new Promise((resolve) => {
    uni.getStorage({
      key: 'loginToken',
      success: function(res) {
        resolve(res.data);
      },
      fail: function() {
        resolve('');
      }
    });
  });
};

/**
 * 封装uni-app请求
 * @param {Object} options - 请求配置
 * @returns {Promise} 请求promise
 */
const request = (options) => {
  const { url, method = 'GET', data = {}, header = {} } = options;
  
  // 获取token并发送请求
  return new Promise((resolve, reject) => {
    // 先获取token
    getToken().then(token => {
      // 合并默认header
      const headers = {
        'Content-Type': 'application/json',
        ...header
      };
      
      // 如果有token则添加到请求头
      if (token) {
        headers['Authorization'] = `Bearer ${token}`;
      }
      
      uni.request({
        url,
        method, 
        data,
        header: headers,
        success: (res) => {
          // 全局响应拦截
          if (res.statusCode === 200) {
            // 业务状态码处理
            if (res.data.code === 200) {
              resolve(res.data);
            } else {
              // 业务错误处理 - 静默失败，不显示提示
              reject(res.data);
            }
          } else {
            // HTTP错误处理 - 静默失败，不显示提示
            reject(res);
          }
        },
        fail: (err) => {
          // 网络错误处理 - 静默失败，不显示提示
          reject(err);
        }
      });
    });
  });
};

/**
 * 处理HTTP错误 - 已移除错误提示
 * @param {Number} statusCode - HTTP状态码
 */
const handleHttpError = (statusCode) => {
  // 静默处理错误，不显示任何提示
  console.log(`HTTP错误: ${statusCode}`);
};

/**
 * 封装GET请求
 * @param {String} url - 请求地址
 * @param {Object} params - 请求参数
 * @param {Object} header - 请求头
 * @returns {Promise} 请求promise
 */
const get = (url, params = {}, header = {}) => {
  // 处理URL参数
  let requestUrl = url;
  
  if (Object.keys(params).length > 0) {
    const query = Object.keys(params)
      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
      .join('&');
    
    requestUrl = `${url}${url.includes('?') ? '&' : '?'}${query}`;
  }
  
  return request({
    url: requestUrl,
    method: 'GET',
    header
  });
};

/**
 * 封装POST请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} header - 请求头
 * @returns {Promise} 请求promise
 */
const post = (url, data = {}, header = {}) => {
  return request({
    url,
    method: 'POST',
    data,
    header
  });
};

/**
 * 封装PUT请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} header - 请求头
 * @returns {Promise} 请求promise
 */
const put = (url, data = {}, header = {}) => {
  return request({
    url,
    method: 'PUT',
    data,
    header
  });
};

/**
 * 封装DELETE请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} header - 请求头
 * @returns {Promise} 请求promise
 */
const del = (url, data = {}, header = {}) => {
  return request({
    url,
    method: 'DELETE',
    data,
    header
  });
};

// 最大重试次数
const MAX_RETRY_COUNT = 3;
// 当前重试次数
let retryCount = 0;

// 处理401错误并刷新token
const handleAuthError = async (error) => {
	console.log("// 处理401错误并刷新token",error)
    if (error.code === 401 && retryCount < MAX_RETRY_COUNT) {
        try {
            // 移除旧的token
            uni.removeStorageSync('loginToken');
            
            // 重新获取用户信息
            const res = await api.user.getWxUserInfo('wangwu7899');
            console.log(res)
            if (res.publisherId != -1) {
                // 存储新的token
                uni.setStorageSync('loginToken', res.token);
                retryCount++;
                return true;
            }
        } catch (refreshError) {
            console.error('刷新token失败', refreshError);
            throw refreshError;
        }
    }
    return false;
};

// 请求拦截器
export const requestInterceptor = async (request) => {
    // 获取token
    const token = uni.getStorageSync('loginToken');
    if (token) {
        request.header = {
            ...request.header,
            'Authorization': `Bearer ${token}`  // 使用Bearer Token格式
        };
    }
    return request;
};

// 响应拦截器
export const responseInterceptor = async (response) => {
    // 用户未注册的情况：code=200且userId=-1
    if (response.data && response.data.code === 200 && response.data.userId === -1) {
        // 重置重试次数
        retryCount = 0;
        
        // 显示未注册提示
        uni.showToast({
            title: '用户未注册',
            icon: 'none',
            duration: 2000
        });
        
        // 直接返回响应，不进行重试
        return response;
    }
    
    // 如果是401错误，尝试刷新token并重试请求
    if (response.statusCode === 401 || (response.data && response.data.code === 401)) {
        try {
            const shouldRetry = await handleAuthError({ code: 401 });
            if (shouldRetry) {
                // 获取原始请求配置
                const originalRequest = response.config || {
                    url: response.url,
                    method: response.method || 'GET',
                    data: response.data
                };
                
                // 使用新token重新发起请求
                const newRequest = {
                    ...originalRequest,
                    header: {
                        ...(originalRequest.header || {}),
                        'Authorization': `Bearer ${uni.getStorageSync('loginToken')}`
                    }
                };
                
                // 直接返回重试后的结果
                return new Promise((resolve, reject) => {
                    uni.request({
                        ...newRequest,
                        success: (res) => {
                            resolve(res);
                        },
                        fail: (err) => {
                            reject(err);
                        }
                    });
                });
            } else {
                if (retryCount >= MAX_RETRY_COUNT) {
                    uni.showToast({
                        title: '登录已过期，请重新登录',
                        icon: 'none',
                        duration: 2000
                    });
                    // 重置重试次数
                    retryCount = 0;
                    // 跳转到登录页
                    setTimeout(() => {
                        uni.navigateTo({
                            url: '/pages/login/login'
                        });
                    }, 2000);
                }
                throw new Error('认证失败');
            }
        } catch (error) {
            throw error;
        }
    }
    return response;
};

export default {
  request,
  get,
  post,
  put,
  delete: del
}; 